import axios from 'axios';
import { getConfig } from './apiConfig';

// 存储会话ID
let sessionId = null;

// 标记是否是首次请求
let isFirstRequest = true;

// 获取API配置
const getApiConfig = () => {
  const config = getConfig();
  return {
    API_KEY: config.apiKey,
    BASE_URL: config.baseUrl,
    CHAT_ID: config.chatId
  };
};

// 创建axios实例
const createApiClient = () => {
  const { API_KEY, BASE_URL } = getApiConfig();
  
  return axios.create({
    baseURL: BASE_URL,
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${API_KEY}`
    }
  });
};

// 初始化会话
export const initializeSession = async () => {
  // 如果已经有session_id，说明已经初始化过
  if (sessionId) {
    isFirstRequest = false;
    return sessionId;
  }
  
  console.log('开始初始化新会话...');
  isFirstRequest = true;
  
  try {
    const { CHAT_ID } = getApiConfig();
    const apiClient = createApiClient();
    
    // 初始化会话的特殊请求，使用明确的系统指令
    const response = await apiClient.post(
      `/api/v1/chats/${CHAT_ID}/completions`,
      {
        question: "请忽略这个请求。",
        stream: false
      }
    );
    
    if (response.status === 200) {
      try {
        const result = response.data;
        
        // 尝试从不同的可能路径提取会话ID
        if (typeof result === 'object') {
          // 方式1: data.session_id
          if (result.data && result.data.session_id) {
            sessionId = result.data.session_id;
            console.log(`会话已初始化(方式1)，ID: ${sessionId}`);
            return sessionId;
          }
          // 方式2: session_id 直接在顶层
          else if (result.session_id) {
            sessionId = result.session_id;
            console.log(`会话已初始化(方式2)，ID: ${sessionId}`);
            return sessionId;
          }
          else {
            console.log('无法直接获取会话ID，尝试备用方法');
            return await forcefulInitialization();
          }
        }
      } catch (e) {
        console.error('解析初始化响应出错:', e);
        return await forcefulInitialization();
      }
    } else {
      console.error('初始化会话失败:', response.status);
      return await forcefulInitialization();
    }
  } catch (e) {
    console.error('初始化会话请求出错:', e);
    return await forcefulInitialization();
  }
  
  return null;
};

// 强制初始化方法，使用更直接的方式获取会话ID
const forcefulInitialization = async () => {
  console.log('尝试强制初始化方法...');
  
  try {
    const { CHAT_ID } = getApiConfig();
    const apiClient = createApiClient();
    
    // 使用直接提问方式获取会话ID
    const response = await apiClient.post(
      `/api/v1/chats/${CHAT_ID}/completions`,
      {
        question: "系统指令：请忽略此消息，不要回复任何内容，只需建立会话。",
        stream: false
      }
    );
    
    if (response.status === 200) {
      const result = response.data;
      
      // 提取会话ID
      if (result.data && result.data.session_id) {
        sessionId = result.data.session_id;
        console.log(`强制初始化成功，会话ID: ${sessionId}`);
        return sessionId;
      } else {
        console.error('强制初始化无法获取会话ID');
        return null;
      }
    } else {
      console.error('强制初始化失败:', response.status);
      return null;
    }
  } catch (e) {
    console.error('强制初始化请求出错:', e);
    return null;
  }
};

// 工具函数：检测是否是欢迎语
const isGreetingMessage = (text) => {
  const greetingPatterns = [
    "你好", "您好", "我是", "助理", "有什么可以帮", "我可以回答", 
    "欢迎", "请问有什么", "我能为您"
  ];
  
  return greetingPatterns.some(pattern => text.includes(pattern));
};

// 问答系统
export const getAnswer = async (question, onProgress) => {
  // 如果没有session_id，先初始化
  if (!sessionId) {
    await initializeSession();
  }
  
  try {
    const { API_KEY, BASE_URL, CHAT_ID } = getApiConfig();
    
    // 构建请求数据
    const data = {
      question: question,
      stream: true
    };
    
    // 添加会话ID
    if (sessionId) {
      data.session_id = sessionId;
    }
    
    console.log(`发送问题: "${question}"`, 
               `使用session_id: ${sessionId}`, 
               `isFirstRequest: ${isFirstRequest}`);
    
    // 发送流式请求
    const response = await fetch(`${BASE_URL}/api/v1/chats/${CHAT_ID}/completions`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${API_KEY}`
      },
      body: JSON.stringify(data)
    });
    
    if (response.ok) {
      let fullAnswer = '';
      let currentChunk = '';
      let hasDetectedAnswer = false; // 是否检测到有效回答
      let buffer = ''; // 用于存储跨块的不完整JSON
      let firstResponseProcessed = false; // 是否已处理第一个响应
      let inWelcomeMode = false; // 是否正处于欢迎语模式
      
      // 处理流式响应
      const reader = response.body.getReader();
      const decoder = new TextDecoder('utf-8');
      
      // 如果是首次请求，先显示加载提示
      if (isFirstRequest && onProgress) {
        onProgress("正在获取回答...");
      }
      
      while (true) {
        const { done, value } = await reader.read();
        if (done) break;
        
        // 解码当前数据块并添加到缓冲区
        const chunk = decoder.decode(value, { stream: true });
        buffer += chunk;
        
        // 尝试从缓冲区中提取完整的数据行
        const lines = buffer.split('\n');
        // 保留最后一行（可能不完整）
        buffer = lines.pop() || '';
        
        for (const line of lines) {
          if (line.startsWith('data:')) {
            let jsonStr = line.substring(5).trim();
            
            try {
              const result = JSON.parse(jsonStr);
              
              // 检查是否是最后一条消息（布尔值true）
              if (typeof result.data === 'boolean') {
                continue;
              }
              
              // 如果是首次请求，保存会话ID
              if (!sessionId && result.data && result.data.session_id) {
                sessionId = result.data.session_id;
                console.log(`新会话ID创建: ${sessionId}`);
              }
              
              // 提取回答内容
              if (result.data && result.data.answer) {
                // 获取当前响应块中的答案
                const answerText = result.data.answer;
                
                // 检查是否是首次响应且是欢迎语
                if (!firstResponseProcessed && isFirstRequest && isGreetingMessage(answerText)) {
                  console.log('首次响应检测到欢迎语，已忽略:', answerText);
                  inWelcomeMode = true;
                  firstResponseProcessed = true;
                  
                  // 提示正在处理中
                  if (onProgress) {
                    onProgress("正在思考您的问题...");
                  }
                  continue;
                }
                
                firstResponseProcessed = true;
                
                // 如果已经在欢迎语模式，且这个响应也是欢迎语的一部分，继续忽略
                if (inWelcomeMode && isGreetingMessage(answerText)) {
                  console.log('继续忽略欢迎语:', answerText);
                  continue;
                }
                
                // 退出欢迎语模式
                inWelcomeMode = false;
                
                // 清理特殊标记
                const cleanedText = cleanText(answerText);
                
                // 对于流式响应，我们需要计算增量部分
                if (cleanedText.length > currentChunk.length) {
                  // 有新内容，保存当前块
                  currentChunk = cleanedText;
                  
                  // 应用关键词加粗
                  fullAnswer = boldifyKeywords(cleanedText);
                  hasDetectedAnswer = true;
                  
                  // 触发进度回调
                  if (onProgress) {
                    onProgress(fullAnswer);
                  }
                }
              }
            } catch (e) {
              console.error('解析JSON出错:', e, 'JSON字符串:', jsonStr);
            }
          }
        }
      }
      
      // 完成处理，将非首次请求标记
      isFirstRequest = false;
      
      // 如果没有检测到任何有效回答（整个流中都是欢迎语）
      if (!hasDetectedAnswer) {
        // 尝试第二次请求获取实际答案
        console.log('未检测到有效回答，尝试第二次请求');
        return getAnswer(question, onProgress);
      }
      
      return { answer: fullAnswer };
    } else {
      const errorMsg = `请求失败: ${response.status}`;
      console.error(errorMsg);
      return { answer: errorMsg };
    }
  } catch (e) {
    const errorMsg = `发生错误: ${e.message}`;
    console.error(errorMsg);
    return { answer: errorMsg };
  }
};

// 测试系统
export const evaluateAnswer = async (question, answer, onProgress) => {
  // 如果没有session_id，先初始化
  if (!sessionId) {
    await initializeSession();
  }
  
  try {
    const { API_KEY, BASE_URL, CHAT_ID } = getApiConfig();
    
    // 构建提示词，让大模型评估答案
    const prompt = `问题：${question}\n学生答案：${answer}\n请评估这个答案的正确性，并给出评分（完全正确/部分正确/回答错误）以及详细解释。`;
    
    // 构建请求数据
    const data = {
      question: prompt,
      stream: true
    };
    
    // 添加会话ID
    if (sessionId) {
      data.session_id = sessionId;
    }
    
    console.log(`发送评估请求，使用session_id: ${sessionId}`, 
               `isFirstRequest: ${isFirstRequest}`);
    
    // 发送流式请求
    const response = await fetch(`${BASE_URL}/api/v1/chats/${CHAT_ID}/completions`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${API_KEY}`
      },
      body: JSON.stringify(data)
    });
    
    if (response.ok) {
      let fullAnswer = '';
      let currentChunk = '';
      let hasDetectedAnswer = false; // 是否检测到有效回答
      let buffer = ''; // 用于存储跨块的不完整JSON 
      let firstResponseProcessed = false; // 是否已处理第一个响应
      let inWelcomeMode = false; // 是否正处于欢迎语模式
      
      // 处理流式响应
      const reader = response.body.getReader();
      const decoder = new TextDecoder('utf-8');
      
      // 如果是首次请求，先显示加载提示
      if (isFirstRequest && onProgress) {
        onProgress("正在评估答案...");
      }
      
      while (true) {
        const { done, value } = await reader.read();
        if (done) break;
        
        // 解码当前数据块并添加到缓冲区
        const chunk = decoder.decode(value, { stream: true });
        buffer += chunk;
        
        // 尝试从缓冲区中提取完整的数据行
        const lines = buffer.split('\n');
        // 保留最后一行（可能不完整）
        buffer = lines.pop() || '';
        
        for (const line of lines) {
          if (line.startsWith('data:')) {
            let jsonStr = line.substring(5).trim();
            
            try {
              const result = JSON.parse(jsonStr);
              
              // 检查是否是最后一条消息（布尔值true）
              if (typeof result.data === 'boolean') {
                continue;
              }
              
              // 提取回答内容
              if (result.data && result.data.answer) {
                // 获取当前响应块中的答案
                const answerText = result.data.answer;
                
                // 检查是否是首次响应且是欢迎语
                if (!firstResponseProcessed && isFirstRequest && isGreetingMessage(answerText)) {
                  console.log('测试系统检测到欢迎语，已忽略:', answerText);
                  inWelcomeMode = true; 
                  firstResponseProcessed = true;
                  
                  // 提示正在处理中
                  if (onProgress) {
                    onProgress("正在分析答案...");
                  }
                  continue;
                }
                
                firstResponseProcessed = true;
                
                // 如果已经在欢迎语模式，且这个响应也是欢迎语的一部分，继续忽略
                if (inWelcomeMode && isGreetingMessage(answerText)) {
                  console.log('继续忽略欢迎语:', answerText);
                  continue;
                }
                
                // 退出欢迎语模式
                inWelcomeMode = false;
                
                // 清理特殊标记
                const cleanedText = cleanText(answerText);
                
                // 对于流式响应，我们需要计算增量部分
                if (cleanedText.length > currentChunk.length) {
                  // 有新内容，保存当前块
                  currentChunk = cleanedText;
                  
                  // 应用评分高亮
                  fullAnswer = highlightEvaluation(cleanedText);
                  hasDetectedAnswer = true;
                  
                  // 触发进度回调
                  if (onProgress) {
                    onProgress(fullAnswer);
                  }
                }
              }
            } catch (e) {
              console.error('解析JSON出错:', e, 'JSON字符串:', jsonStr);
            }
          }
        }
      }
      
      // 完成处理，将非首次请求标记
      isFirstRequest = false;
      
      // 如果没有检测到任何有效回答（整个流中都是欢迎语）
      if (!hasDetectedAnswer) {
        // 尝试第二次请求获取实际答案
        console.log('测试系统未检测到有效回答，尝试第二次请求');
        return evaluateAnswer(question, answer, onProgress);
      }
      
      return { answer: fullAnswer };
    } else {
      const errorMsg = `请求失败: ${response.status}`;
      console.error(errorMsg);
      return { answer: errorMsg };
    }
  } catch (e) {
    const errorMsg = `发生错误: ${e.message}`;
    console.error(errorMsg);
    return { answer: errorMsg };
  }
};

// 重置会话
export const resetSession = async () => {
  try {
    const oldSessionId = sessionId;
    sessionId = null;
    // 重置首次请求标记
    isFirstRequest = true;
    console.log(`会话已重置，旧ID: ${oldSessionId}`);
    
    // 立即初始化新会话并等待完成
    const newSessionId = await initializeSession();
    
    if (newSessionId) {
      console.log(`会话重置成功，新ID: ${newSessionId}`);
      return { message: '会话已重置，开始新的对话。' };
    } else {
      console.error('会话重置失败，无法获取新会话ID');
      return { message: '会话重置失败，请刷新页面重试。' };
    }
  } catch (error) {
    console.error('会话重置过程中发生错误:', error);
    return { message: '会话重置过程中发生错误，请刷新页面重试。' };
  }
};

// 工具函数：清理文本中的特殊标记
const cleanText = (text) => {
  // 清理特殊标记
  let cleanedText = text;
  cleanedText = cleanedText.replace(/[（(]##\d+\$\$[）)]/g, '');
  cleanedText = cleanedText.replace(/##\d+\$\$/g, '');
  cleanedText = cleanedText.replace(/\[##\d+\$\$\]/g, '');
  
  return cleanedText;
};

// 工具函数：突出显示评分结果
const highlightEvaluation = (text) => {
  return text.replace(/(完全正确|部分正确|回答错误)/g, '**$1**');
};

// 自动加粗关键词
export const boldifyKeywords = (text) => {
  if (!text) return '';
  
  const keywords = [
    "TCP", "IP", "UDP", "HTTP", "HTTPS", "FTP", "DNS", "OSI", "以太网",
    "路由器", "交换机", "网关", "子网掩码", "MAC地址", "IP地址", "ARP", "ICMP",
    "网络层", "传输层", "应用层", "数据链路层", "物理层", "会话层", "表示层",
    "拥塞控制", "流量控制", "三次握手", "四次挥手", "滑动窗口", "CSMA/CD",
    "分组", "帧", "报文", "数据报", "比特", "字节", "协议"
  ];
  
  let result = text;
  
  // 对每个关键词进行处理
  keywords.forEach(keyword => {
    // 首先检查文本中是否有关键词
    if (result.includes(keyword)) {
      // 使用简单的字符串替换，不使用复杂的正则表达式
      const parts = result.split(keyword);
      result = '';
      
      // 重新组合文本，添加粗体标记
      for (let i = 0; i < parts.length; i++) {
        result += parts[i];
        
        // 在最后一部分后不添加关键词
        if (i < parts.length - 1) {
          // 检查前后是否已经有星号（避免重复加粗）
          const beforeHasStars = parts[i].endsWith('*') || parts[i].endsWith('**');
          const afterHasStars = (i < parts.length - 1) && (parts[i + 1].startsWith('*') || parts[i + 1].startsWith('**'));
          
          if (!beforeHasStars && !afterHasStars) {
            result += `**${keyword}**`;
          } else {
            result += keyword;
          }
        }
      }
    }
  });
  
  return result;
};

// 案例检索系统
export const searchCases = async (description, type, year, onProgress) => {
  // 如果没有session_id，先初始化
  if (!sessionId) {
    await initializeSession();
  }
  
  try {
    const { API_KEY, BASE_URL, CHAT_ID } = getApiConfig();
    
    // 构建案例检索提示
    let prompt = `请针对以下案情描述，提供相似案例分析、法律依据和专业意见：\n\n${description}`;
    
    // 添加筛选条件
    if (type) {
      if (type === 'civil') {
        prompt += '\n\n仅查找民事案件相关案例。';
      } else if (type === 'criminal') {
        prompt += '\n\n仅查找刑事案件相关案例。';
      } else if (type === 'administrative') {
        prompt += '\n\n仅查找行政案件相关案例。';
      } else if (type === 'enforcement') {
        prompt += '\n\n仅查找执行案件相关案例。';
      }
    }
    
    if (year) {
      if (year === 'older') {
        prompt += '\n\n仅查找2020年以前的案例。';
      } else {
        prompt += `\n\n优先查找${year}年的案例。`;
      }
    }
    
    // 构建请求数据
    const data = {
      question: prompt,
      stream: true
    };
    
    // 添加会话ID
    if (sessionId) {
      data.session_id = sessionId;
    }
    
    console.log(`发送案例检索请求: "${description}"`, 
               `使用session_id: ${sessionId}`);
    
    // 发送流式请求
    const response = await fetch(`${BASE_URL}/api/v1/chats/${CHAT_ID}/completions`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${API_KEY}`
      },
      body: JSON.stringify(data)
    });
    
    if (response.ok) {
      let fullAnswer = '';
      let currentChunk = '';
      let buffer = ''; // 用于存储跨块的不完整JSON
      
      // 处理流式响应
      const reader = response.body.getReader();
      const decoder = new TextDecoder('utf-8');
      
      // 先显示加载提示
      if (onProgress) {
        onProgress("正在检索相关案例...");
      }
      
      while (true) {
        const { done, value } = await reader.read();
        if (done) break;
        
        // 解码二进制数据为文本
        const text = decoder.decode(value);
        buffer += text;
        
        // 尝试解析每一行作为单独的JSON对象
        const lines = buffer.split('\n');
        buffer = lines.pop() || ''; // 最后一行可能不完整，保留到下一次
        
        for (const line of lines) {
          if (!line.trim()) continue;
          
          try {
            // 解析JSON响应
            const json = JSON.parse(line);
            
            if (json.data && json.data.text) {
              const chunk = json.data.text;
              fullAnswer += chunk;
              currentChunk += chunk;
              
              // 积累一定长度的文本再更新UI
              if (currentChunk.length > 10 && onProgress) {
                onProgress(boldifyKeywords(fullAnswer));
                currentChunk = '';
              }
            }
            
            // 保存会话ID（如果是首次请求）
            if (json.data && json.data.session_id && !sessionId) {
              sessionId = json.data.session_id;
              console.log(`获取到会话ID: ${sessionId}`);
            }
          } catch (e) {
            console.warn('无法解析响应行:', line, e);
          }
        }
      }
      
      // 最后一次更新UI
      if (onProgress) {
        const processedAnswer = boldifyKeywords(fullAnswer);
        onProgress(processedAnswer);
      }
      
      console.log('案例检索完成，回答长度:', fullAnswer.length);
      return { answer: boldifyKeywords(fullAnswer) };
    } else {
      console.error('案例检索请求失败:', response.status);
      return { answer: '检索失败，请稍后重试。' };
    }
  } catch (error) {
    console.error('案例检索错误:', error);
    return { answer: `检索出错: ${error.message}` };
  }
};

// 使用OpenAI兼容API接口查询
export const searchWithOpenAI = async (prompt, onProgress) => {
  try {
    const { openaiApiKey, openaiBaseUrl, openaiModel } = getConfig();
    
    if (!openaiApiKey) {
      return { answer: "未配置OpenAI API Key，请在系统配置中设置。" };
    }
    
    // 构建OpenAI请求数据
    const data = {
      model: openaiModel,
      messages: [
        { role: "system", content: "你是一个专业的法律顾问，擅长法律分析和案例检索。请基于用户的描述，提供详细的法律分析、相关法条引用和类似案例。" },
        { role: "user", content: prompt }
      ],
      stream: true,
      temperature: 0.7
    };
    
    console.log(`发送OpenAI请求: "${prompt.substring(0, 100)}..."`);
    
    const response = await fetch(`${openaiBaseUrl}/chat/completions`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${openaiApiKey}`
      },
      body: JSON.stringify(data)
    });
    
    if (response.ok) {
      let fullAnswer = '';
      let currentChunk = '';
      
      if (onProgress) {
        onProgress("正在生成回答...");
      }
      
      const reader = response.body.getReader();
      const decoder = new TextDecoder('utf-8');
      
      while (true) {
        const { done, value } = await reader.read();
        if (done) break;
        
        // 解码二进制数据为文本
        const text = decoder.decode(value);
        const lines = text.split('\n');
        
        for (const line of lines) {
          if (line.startsWith('data: ') && line !== 'data: [DONE]') {
            try {
              const json = JSON.parse(line.substring(6));
              if (json.choices && json.choices[0] && json.choices[0].delta && json.choices[0].delta.content) {
                const chunk = json.choices[0].delta.content;
                fullAnswer += chunk;
                currentChunk += chunk;
                
                // 积累一定长度的文本再更新UI
                if (currentChunk.length > 10 && onProgress) {
                  onProgress(boldifyKeywords(fullAnswer));
                  currentChunk = '';
                }
              }
            } catch (e) {
              console.warn('无法解析OpenAI响应:', line, e);
            }
          }
        }
      }
      
      // 最后一次更新UI
      if (onProgress) {
        const processedAnswer = boldifyKeywords(fullAnswer);
        onProgress(processedAnswer);
      }
      
      console.log('OpenAI回答完成，回答长度:', fullAnswer.length);
      return { answer: boldifyKeywords(fullAnswer) };
    } else {
      console.error('OpenAI请求失败:', response.status);
      const errorText = await response.text();
      console.error('错误详情:', errorText);
      return { answer: `请求失败(${response.status}): ${errorText}` };
    }
  } catch (error) {
    console.error('OpenAI请求错误:', error);
    return { answer: `请求出错: ${error.message}` };
  }
}; 